package service

import (
	"errors"
	"fitness/go-admin/internal/model"
	"fitness/go-admin/internal/repository"

	"gorm.io/gorm"
)

type UserService interface {
	GetUserList(req *model.UserListReq) ([]*model.UserListItem, int64, error)
	GetUserDetail(userID uint) (*model.UserDetailResp, error)
	UpdateUserInfo(userID uint, req *model.UpdateUserReq) error
	UpdateUserStatus(userID uint, req *model.UpdateUserStatusReq, adminID uint) error
	UpdateUserRole(userID uint, req *model.UpdateUserRoleReq, adminID uint) error
}

type userService struct {
	userRepo repository.UserRepository
	roleRepo repository.RoleRepository
}

func NewUserService(userRepo repository.UserRepository, roleRepo repository.RoleRepository) UserService {
	return &userService{
		userRepo: userRepo,
		roleRepo: roleRepo,
	}
}

// GetUserList 获取用户列表
func (s *userService) GetUserList(req *model.UserListReq) ([]*model.UserListItem, int64, error) {
	// 参数验证
	if req.Page < 1 {
		req.Page = 1
	}
	if req.PageSize < 1 || req.PageSize > 100 {
		req.PageSize = 10
	}

	// 角色验证
	if req.Role != "" {
		validRoles := map[string]bool{"admin": true, "coach": true, "member": true}
		if !validRoles[req.Role] {
			return nil, 0, errors.New("无效的角色类型")
		}
	}

	// 状态验证
	if req.Status != nil && (*req.Status != 0 && *req.Status != 1) {
		return nil, 0, errors.New("无效的状态值")
	}

	// 调用Repository层查询
	users, total, err := s.userRepo.GetUserListWithFilter(req)
	if err != nil {
		return nil, 0, err
	}

	return users, total, nil
}

// GetUserDetail 获取用户详情
func (s *userService) GetUserDetail(userID uint) (*model.UserDetailResp, error) {
	// 参数验证
	if userID == 0 {
		return nil, errors.New("用户ID不能为空")
	}

	// 调用Repository层查询
	detail, err := s.userRepo.GetUserDetailByID(userID)
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return nil, errors.New("用户不存在")
		}
		return nil, err
	}

	return detail, nil
}

// UpdateUserInfo 更新用户信息(管理员)
func (s *userService) UpdateUserInfo(userID uint, req *model.UpdateUserReq) error {
	// 参数验证
	if userID == 0 {
		return errors.New("用户ID不能为空")
	}

	// 检查用户是否存在
	_, err := s.userRepo.GetByID(userID)
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return errors.New("用户不存在")
		}
		return err
	}

	// 邮箱格式验证
	if req.Email != "" {
		if !isValidEmail(req.Email) {
			return errors.New("邮箱格式不正确")
		}
		// 检查邮箱是否已被使用
		exists, err := s.userRepo.CheckEmailExists(req.Email, userID)
		if err != nil {
			return err
		}
		if exists {
			return errors.New("邮箱已被其他用户使用")
		}
	}

	// 手机号格式验证
	if req.Phone != "" {
		if !isValidPhone(req.Phone) {
			return errors.New("手机号格式不正确")
		}
		// 检查手机号是否已被使用
		exists, err := s.userRepo.CheckPhoneExists(req.Phone, userID)
		if err != nil {
			return err
		}
		if exists {
			return errors.New("手机号已被其他用户使用")
		}
	}

	// 执行更新
	return s.userRepo.UpdateUserInfo(userID, req)
}

// isValidEmail 验证邮箱格式
func isValidEmail(email string) bool {
	if email == "" {
		return true
	}
	// 简单的邮箱格式校验
	return len(email) > 3 && len(email) < 100 &&
		contains(email, "@") && contains(email, ".")
}

// isValidPhone 验证手机号格式(中国大陆)
func isValidPhone(phone string) bool {
	if phone == "" {
		return true
	}
	// 中国大陆手机号11位数字，1开头
	return len(phone) == 11 && phone[0] == '1'
}

// contains 检查字符串是否包含子串
func contains(s, substr string) bool {
	for i := 0; i < len(s)-len(substr)+1; i++ {
		if s[i:i+len(substr)] == substr {
			return true
		}
	}
	return false
}

// UpdateUserStatus 更新用户状态(管理员)
func (s *userService) UpdateUserStatus(userID uint, req *model.UpdateUserStatusReq, adminID uint) error {
	// 参数验证
	if userID == 0 {
		return errors.New("用户ID不能为空")
	}

	// 管理员不能禁用自己
	if userID == adminID && req.Status == 0 {
		return errors.New("不能禁用自己的账号")
	}

	// 检查用户是否存在
	_, err := s.userRepo.GetByID(userID)
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return errors.New("用户不存在")
		}
		return err
	}

	// 执行更新
	return s.userRepo.UpdateUserStatus(userID, req.Status)
}

// UpdateUserRole 修改用户角色(管理员)
func (s *userService) UpdateUserRole(userID uint, req *model.UpdateUserRoleReq, adminID uint) error {
	// 参数验证
	if userID == 0 {
		return errors.New("用户ID不能为空")
	}

	// 管理员不能修改自己的角色
	if userID == adminID {
		return errors.New("不能修改自己的角色")
	}

	// 检查用户是否存在
	_, err := s.userRepo.GetByID(userID)
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return errors.New("用户不存在")
		}
		return err
	}

	// 检查角色是否存在
	role, err := s.roleRepo.GetByID(req.RoleID)
	if err != nil {
		if err == gorm.ErrRecordNotFound {
			return errors.New("角色不存在")
		}
		return err
	}

	// 检查角色状态
	if role.Status != 1 {
		return errors.New("角色已被禁用")
	}

	// 执行更新
	return s.userRepo.UpdateUserRole(userID, req.RoleID)
}
